using Android.App;
using Android.App;
using Android.Content;
using Android.OS;
using AndroidX.Core.App;
using MauiBuilder.Services;
using System.Timers;
using Microsoft.Maui.Media;

namespace MauiBuilder.Platforms.Android
{
    /// <summary>
    /// 前台服务类 - 提供持续运行的后台服务功能
    /// 该服务会在状态栏显示持续通知，确保系统不会随意杀死服务进程
    /// </summary>
    [Service(ForegroundServiceType = global::Android.Content.PM.ForegroundService.TypeDataSync)]
    public class ForegroundService : Service
    {
        /// <summary>
        /// 通知ID - 用于标识前台服务的通知
        /// </summary>
        private const int NotificationId = 1001;
        
        /// <summary>
        /// 通知渠道ID - Android 8.0及以上版本需要通知渠道
        /// </summary>
        private const string ChannelId = "ForegroundServiceChannel";
        
        /// <summary>
        /// 通知管理器
        /// </summary>
        private NotificationManager? _notificationManager;
        
        /// <summary>
        /// 当前服务实例
        /// </summary>
        private static ForegroundService? _currentInstance;

        /// <summary>
        /// 日志管理器
        /// </summary>
        private LogManager _logManager = LogManager.Instance;

        /// <summary>
        /// 报时检查定时器 - 每分钟检查一次
        /// </summary>
        private System.Timers.Timer? _chimeCheckTimer;

        /// <summary>
        /// 报时通知ID起始值
        /// </summary>
        private const int ChimeNotificationId = 2001;

        /// <summary>
        /// TTS初始化状态标志
        /// </summary>
        private bool _isTtsInitialized = false;

        /// <summary>
        /// 语音合成选项
        /// </summary>
        private SpeechOptions? _speechOptions;

        /// <summary>
        /// 上次报时时间 - 用于防止重复报时
        /// </summary>
        private DateTime _lastChimeTime = DateTime.MinValue;
    
    

        /// <summary>
        /// 服务创建时的回调方法
        /// 在这里进行服务的初始化工作
        /// </summary>
        public override void OnCreate()
        {
            base.OnCreate();
            _currentInstance = this;
            _notificationManager = (NotificationManager?)GetSystemService(NotificationService);

            CreateNotificationChannel(); // 创建前台服务通知渠道
            StartChimeTimer();
            _ = InitializeTtsAsync(); // 初始化语音合成引擎
            
            _logManager.LogInfo("前台服务正在创建");
            
            // 检查通知管理器是否正常
            if (_notificationManager != null)
            {
                _logManager.LogInfo("通知管理器初始化成功");
            }
            else
            {
                _logManager.LogInfo("警告：通知管理器初始化失败");
            }
        }

        /// <summary>
        /// 服务启动命令处理方法
        /// 当通过StartService或StartForegroundService启动服务时会调用此方法
        /// </summary>
        /// <param name="intent">启动服务的Intent对象</param>
        /// <param name="flags">启动标志</param>
        /// <param name="startId">启动ID</param>
        /// <returns>服务重启策略</returns>
        public override StartCommandResult OnStartCommand(Intent? intent, StartCommandFlags flags, int startId)
        {
            _logManager.LogInfo("前台服务启动命令执行");
            
            var notification = CreateNotification();
            StartForeground(NotificationId, notification);
            _logManager.LogInfo("前台服务通知已创建并显示");
            
            return StartCommandResult.Sticky;
        }

        /// <summary>
        /// 绑定服务时的回调方法
        /// 由于这是一个前台服务，不需要绑定功能，返回null
        /// </summary>
        /// <param name="intent">绑定服务的Intent对象</param>
        /// <returns>服务绑定器，这里返回null表示不支持绑定</returns>
        public override IBinder? OnBind(Intent? intent)
        {
            return null;
        }

        /// <summary>
        /// 获取服务实例
        /// </summary>
        /// <returns>服务实例</returns>
        public static ForegroundService? GetServiceInstance()
        {
            return _currentInstance;
        }

        /// <summary>
        /// 创建前台服务通知渠道
        /// </summary>
        private void CreateNotificationChannel()
        {
            if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
            {
                var channel = new NotificationChannel(
                    ChannelId,
                    "前台服务通知",
                    NotificationImportance.Low)
                {
                    Description = "用于显示前台服务状态的通知渠道"
                };

                // 设置为静默通知，不需要声音和振动
                channel.EnableVibration(false);
                channel.EnableLights(false);
                channel.SetSound(null, null);
                channel.SetShowBadge(false);

                _notificationManager?.CreateNotificationChannel(channel);
                _logManager.LogInfo("前台服务通知渠道已创建");
            }
        }
        /// <summary>
        /// 初始化语音合成引擎
        /// 使用 .NET MAUI TextToSpeech API
        /// </summary>
        private async Task InitializeTtsAsync()
        {
            try
            {

                _logManager.LogInfo("开始初始化 .NET MAUI 语音合成引擎");

                // 获取可用语言
                var locales = await TextToSpeech.Default.GetLocalesAsync();
                var chosenLocale = locales.FirstOrDefault(locale => locale.Language.Contains("zh"));
                
                if (chosenLocale == null)
                {
                    _logManager.LogWarning("未找到中文语言支持，将使用默认语言");
                    chosenLocale = locales.FirstOrDefault();
                }
                else
                {
                    _logManager.LogInfo($"找到中文语言支持：{chosenLocale.Language}-{chosenLocale.Country}");
                }
                
                // 设置语音选项
                _speechOptions = new SpeechOptions()
                {
                    Pitch = 1.0f,     // 音调范围：0.0 - 2.0
                    Volume = 0.8f,    // 音量范围：0.0 - 1.0
                    Locale = chosenLocale
                };
                
                // 测试TTS是否可用
                //await TextToSpeech.Default.SpeakAsync("", _speechOptions, CancellationToken.None);
                
                _isTtsInitialized = true;
                _logManager.LogInfo("✅ .NET MAUI TTS初始化成功！");


                _logManager.LogInfo("报时服务初始化成功");

            }
            catch (Exception ex)
            {
                _logManager.LogError($"❌ .NET MAUI TTS初始化失败：{ex.Message}");
                _isTtsInitialized = false;
            }
        }

        /// <summary>
        /// 启动报时检查定时器
        /// </summary>
        private void StartChimeTimer()
        {
            try
            {
                // 每30秒检查一次，确保不会错过整点
                _chimeCheckTimer = new System.Timers.Timer(10000);
                _chimeCheckTimer.Elapsed += OnChimeTimerElapsed;
                _chimeCheckTimer.AutoReset = true;
                _chimeCheckTimer.Start();
                
                _logManager.LogInfo("报时检查定时器已启动，每30秒检查一次");
            }
            catch (Exception ex)
            {
                _logManager.LogError($"启动报时定时器失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 报时检查定时器事件
        /// </summary>
        private async void OnChimeTimerElapsed(object? sender, ElapsedEventArgs e)
        {
            try
            {
                await PerformVoiceChimeAsync();
            }
            catch (Exception ex)
            {
                _logManager.LogError($"报时检查失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 执行语音报时
        /// </summary>
        private async Task PerformVoiceChimeAsync()
        {
            try
            {
                if (!_isTtsInitialized)
                {
                    _logManager.LogWarning("语音合成引擎未初始化，无法进行语音报时");
                    return;
                }

                var now = DateTime.Now;
                
                // 检查是否为整点（允许5秒误差）
                if (!(now.Minute == 0 || (now - _lastChimeTime).TotalHours >= 1))
                {
                    return; // 不是整点，不进行报时
                }
                
                
                string speechText = $"现在时间是 {now.Hour} 点整";
                
                // 使用 .NET MAUI TextToSpeech API 执行语音播放
                await TextToSpeech.Default.SpeakAsync(speechText, _speechOptions, CancellationToken.None);
                
                // 更新上次报时时间
                _lastChimeTime = DateTime.Parse($"{now.ToString("yyyy-MM-dd HH")}:00:00");
                
                _logManager.LogInfo($"语音报时成功：{speechText}，更新报时时间为 {now:HH:mm:ss}");
            }
            catch (Exception ex)
            {
                _logManager.LogError($"语音报时出现异常：{ex.Message}");
            }
        }
        

        /// <summary>
        /// 创建前台服务通知
        /// 该通知将持续显示在状态栏中，告知用户服务正在运行
        /// </summary>
        /// <returns>构建好的通知对象</returns>
        private Notification CreateNotification()
        {
            try
            {
                // 创建点击意图，点击通知时打开应用
                var intent = new Intent(this, typeof(MainActivity));
                intent.SetFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);
                var pendingIntent = PendingIntent.GetActivity(this, 0, intent, 
                    PendingIntentFlags.UpdateCurrent | PendingIntentFlags.Immutable);

                var builder = new NotificationCompat.Builder(this, ChannelId)
                    .SetContentTitle("前台服务运行中")
                    .SetContentText("应用正在后台运行，提供准点报时服务")
                    .SetSmallIcon(global::Android.Resource.Drawable.IcMenuInfoDetails)
                    .SetContentIntent(pendingIntent) // 添加点击意图
                    .SetOngoing(true)                // 设置为持续通知
                    .SetPriority(NotificationCompat.PriorityLow)
                    .SetAutoCancel(false)           // 不自动取消
                    .SetOnlyAlertOnce(true)         // 只在首次显示时提醒
                    .SetShowWhen(false);            // 不显示时间

                var notification = builder.Build();
                _logManager.LogInfo("前台服务通知创建成功");
                return notification;
            }
            catch (Exception ex)
            {
                _logManager.LogError($"创建前台服务通知失败：{ex.Message}");
                
                // 返回一个基本的通知作为后备
                return new NotificationCompat.Builder(this, ChannelId)
                    .SetContentTitle("前台服务")
                    .SetContentText("运行中")
                    .SetSmallIcon(global::Android.Resource.Drawable.IcMenuInfoDetails)
                    .SetOngoing(true)
                    .SetPriority(NotificationCompat.PriorityLow)
                    .Build();
            }
        }

        /// <summary>
        /// 服务销毁时的回调方法
        /// 在这里进行资源清理和服务停止工作
        /// </summary>
        public override void OnDestroy()
        {
            _logManager.LogInfo("前台服务正在销毁");
            
            // 停止报时定时器
            _chimeCheckTimer?.Stop();
            _chimeCheckTimer?.Dispose();
            _chimeCheckTimer = null;
            
            // 重置TTS初始化状态
            _isTtsInitialized = false;
            _speechOptions = null;
            _logManager.LogInfo(".NET MAUI TTS资源已清理");
            
            _currentInstance = null;
            _logManager.LogInfo("前台服务销毁完成");
            base.OnDestroy();
            StopForeground(true);
        }
    }
}